{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# A CNN Mnist Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Installing packages:\n",
      "\t.package(path: \"/home/jupyter/notebooks/swift/FastaiNotebook_05b_early_stopping\")\n",
      "\t\tFastaiNotebook_05b_early_stopping\n",
      "With SwiftPM flags: []\n",
      "Working in: /tmp/tmph4filx0a/swift-install\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "warning: /home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "/home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)[1/10] Compiling FastaiNotebook_05b_early_stopping 03_minibatch_training.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[2/10] Compiling FastaiNotebook_05b_early_stopping 02_fully_connected.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[3/10] Compiling FastaiNotebook_05b_early_stopping 05b_early_stopping.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[4/10] Compiling FastaiNotebook_05b_early_stopping 05_anneal.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[5/10] Compiling FastaiNotebook_05b_early_stopping 02a_why_sqrt5.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[6/10] Compiling FastaiNotebook_05b_early_stopping 00_load_data.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[7/10] Compiling FastaiNotebook_05b_early_stopping 01_matmul.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[8/10] Compiling FastaiNotebook_05b_early_stopping 04_callbacks.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[9/10] Compiling FastaiNotebook_05b_early_stopping 01a_fastai_layers.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[10/11] Merging module FastaiNotebook_05b_early_stopping\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "/home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)[11/12] Compiling jupyterInstalledPackages jupyterInstalledPackages.swift\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "[12/13] Merging module jupyterInstalledPackages\n",
      "/home/jupyter/swift/usr/bin/swift: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift)\n",
      "/home/jupyter/swift/usr/bin/swiftc: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swiftc)\n",
      "/home/jupyter/swift/usr/bin/swift-autolink-extract: /home/jupyter/anaconda3/lib/libuuid.so.1: no version information available (required by /home/jupyter/swift/usr/bin/swift-autolink-extract)\n",
      "[13/13] Linking libjupyterInstalledPackages.so\n",
      "Initializing Swift...\n",
      "Installation complete!\n"
     ]
    }
   ],
   "source": [
    "%install-location $cwd/swift-install\n",
    "%install '.package(path: \"$cwd/FastaiNotebook_05b_early_stopping\")' FastaiNotebook_05b_early_stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export\n",
    "import Path\n",
    "import TensorFlow\n",
    "import Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import FastaiNotebook_05b_early_stopping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('inline', 'module://ipykernel.pylab.backend_inline')\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%include \"EnableIPythonDisplay.swift\"\n",
    "IPythonDisplay.shell.enable_matplotlib(\"inline\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let data = mnistDataBunch(flat: false, bs: 512)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batch size: 512\r\n",
      "Example side size: 28\r\n",
      "Class count: 512\r\n"
     ]
    }
   ],
   "source": [
    "let firstBatch = data.train.ds.first(where: { _ in true })!\n",
    "let batchShape = firstBatch.xb.shape\n",
    "let batchSize = batchShape.dimensions[0]\n",
    "let exampleSideSize = batchShape.dimensions[1]\n",
    "assert(exampleSideSize == batchShape.dimensions[2])\n",
    "print(\"Batch size: \\(batchSize)\")\n",
    "print(\"Example side size: \\(exampleSideSize)\")\n",
    "\n",
    "let classCount = firstBatch.yb.shape.dimensions[0]\n",
    "print(\"Class count: \\(classCount)\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "▿ [512, 28, 28]\n",
       "  ▿ dimensions : 3 elements\n",
       "    - 0 : 512\n",
       "    - 1 : 28\n",
       "    - 2 : 28\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "firstBatch.xb.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "// export\n",
    "extension Learner {\n",
    "    public class AddChannel: Delegate {\n",
    "        public override func batchWillStart(learner: Learner) {\n",
    "            learner.currentInput = learner.currentInput!.expandingShape(at: -1)\n",
    "        }\n",
    "    }\n",
    "    \n",
    "    public func makeAddChannel() -> AddChannel { return AddChannel() }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "//export \n",
    "public struct CnnModel: Layer {\n",
    "    public var convs: [FAConv2D<Float>]\n",
    "    public var pool = FAGlobalAvgPool2D<Float>()\n",
    "    public var linear: FADense<Float>\n",
    "    \n",
    "    public init(channelIn: Int, nOut: Int, filters: [Int]){\n",
    "        let allFilters = [channelIn] + filters\n",
    "        convs = Array(0..<filters.count).map { i in\n",
    "            return FAConv2D(allFilters[i], allFilters[i+1], ks: 3, stride: 2)\n",
    "        }\n",
    "        linear = FADense<Float>(filters.last!, nOut)\n",
    "    }\n",
    "    \n",
    "    @differentiable\n",
    "    public func callAsFunction(_ input: TF) -> TF {\n",
    "        return linear(pool(convs(input)))\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let model = CnnModel(channelIn: 1, nOut: 10, filters: [8, 16, 32, 32])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[512, 10]\r\n",
      "[-0.23888946, -0.17904489,  0.27589405,  0.22169928,   0.2614417,  -0.2746509,  -0.0112212,\r\n",
      " -0.13185278, -0.13168347,  0.16951849]\r\n"
     ]
    }
   ],
   "source": [
    "// Test that data goes through the model as expected.\n",
    "let predictions = model(firstBatch.xb.expandingShape(at: -1))\n",
    "print(predictions.shape)\n",
    "print(predictions[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Compare training on CPU and GPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "func optFunc(_ model: CnnModel) -> SGD<CnnModel> { return SGD(for: model, learningRate: 0.4)}\n",
    "func modelInit() -> CnnModel { return CnnModel(channelIn: 1, nOut: 10, filters: [8, 16, 32, 32]) }\n",
    "let learner = Learner(data: data, lossFunc: softmaxCrossEntropy, optFunc: optFunc, modelInit: modelInit)\n",
    "let recorder = learner.makeDefaultDelegates(metrics: [accuracy])\n",
    "learner.addDelegates([learner.makeNormalize(mean: mnistStats.mean, std: mnistStats.std),\n",
    "                      learner.makeAddChannel()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: [0.38877672, 0.8857]                                                  \n",
      "average: 2399.418786 ms,   min: 2399.418786 ms,   max: 2399.418786 ms      \n"
     ]
    }
   ],
   "source": [
    "// This happens on the GPU (if you have one and it's configured correctly).\n",
    "// I tried this on a GCE 8vCPU 30GB + Tesla P100:\n",
    "// - time: ~4.3s\n",
    "// - nvidia-smi shows ~10% GPU-Util while this is running\n",
    "time { try! learner.fit(1) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: [0.38036653, 0.8828]                                                  \n",
      "average: 3779.773271 ms,   min: 3779.773271 ms,   max: 3779.773271 ms      \n"
     ]
    }
   ],
   "source": [
    "// This happens on the CPU.\n",
    "// I tried this on a GCE 8vCPU 30GB + Tesla P100:\n",
    "// - time: ~6.3s\n",
    "// - nvidia-smi shows 0% GPU-Util while this is running\n",
    "time {\n",
    "    withDevice(.cpu) { try! learner.fit(1) }\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collect Layer Activation Statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ActivationStatsHook {\n",
    "    var means: [Float] = []\n",
    "    var stds: [Float] = []    \n",
    "    func update(_ act: TF) {\n",
    "        means.append(act.mean().scalarized())\n",
    "        stds.append (act.std() .scalarized())\n",
    "    }\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "let learner = Learner(data: data, lossFunc: softmaxCrossEntropy, optFunc: optFunc, modelInit: modelInit)\n",
    "let recorder = learner.makeDefaultDelegates(metrics: [accuracy])\n",
    "learner.addDelegates([learner.makeNormalize(mean: mnistStats.mean, std: mnistStats.std),\n",
    "                      learner.makeAddChannel()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "var statHooks: [ActivationStatsHook] = (0..<learner.model.convs.count).map { i in \n",
    "    var stat = ActivationStatsHook()\n",
    "    learner.model.convs[i].addDelegate(stat.update)\n",
    "    return stat\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0: [0.48905897, 0.8494]                                                  \n",
      "Epoch 1: [0.7344446, 0.7998]                                                   \n",
      "average: 3978.003284 ms,   min: 3978.003284 ms,   max: 3978.003284 ms      \n"
     ]
    }
   ],
   "source": [
    "// This LayerDelegate stuff slows it down to ~6s/epoch.\n",
    "time { try! learner.fit(2) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "None\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for stat in statHooks {\n",
    "    plt.plot(stat.means)\n",
    "}\n",
    "plt.legend(Array(1...statHooks.count))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "None\n"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "for stat in statHooks {\n",
    "    plt.plot(stat.stds)\n",
    "}\n",
    "plt.legend(Array(1...statHooks.count))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Export"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success\r\n"
     ]
    }
   ],
   "source": [
    "import NotebookExport\n",
    "let exporter = NotebookExport(Path.cwd/\"06_cuda.ipynb\")\n",
    "print(exporter.export(usingPrefix: \"FastaiNotebook_\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Swift",
   "language": "swift",
   "name": "swift"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
